home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / sets.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  17KB  |  579 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Classes to represent arbitrary sets (including sets of sets).
  5.  
  6. This module implements sets using dictionaries whose values are
  7. ignored.  The usual operations (union, intersection, deletion, etc.)
  8. are provided as both methods and operators.
  9.  
  10. Important: sets are not sequences!  While they support 'x in s',
  11. 'len(s)', and 'for x in s', none of those operations are unique for
  12. sequences; for example, mappings support all three as well.  The
  13. characteristic operation for sequences is subscripting with small
  14. integers: s[i], for i in range(len(s)).  Sets don't support
  15. subscripting at all.  Also, sequences allow multiple occurrences and
  16. their elements have a definite order; sets on the other hand don't
  17. record multiple occurrences and don't remember the order of element
  18. insertion (which is why they don't support s[i]).
  19.  
  20. The following classes are provided:
  21.  
  22. BaseSet -- All the operations common to both mutable and immutable
  23.     sets. This is an abstract class, not meant to be directly
  24.     instantiated.
  25.  
  26. Set -- Mutable sets, subclass of BaseSet; not hashable.
  27.  
  28. ImmutableSet -- Immutable sets, subclass of BaseSet; hashable.
  29.     An iterable argument is mandatory to create an ImmutableSet.
  30.  
  31. _TemporarilyImmutableSet -- A wrapper around a Set, hashable,
  32.     giving the same hash value as the immutable set equivalent
  33.     would have.  Do not use this class directly.
  34.  
  35. Only hashable objects can be added to a Set. In particular, you cannot
  36. really add a Set as an element to another Set; if you try, what is
  37. actually added is an ImmutableSet built from it (it compares equal to
  38. the one you tried adding).
  39.  
  40. When you ask if `x in y' where x is a Set and y is a Set or
  41. ImmutableSet, x is wrapped into a _TemporarilyImmutableSet z, and
  42. what's tested is actually `z in y'.
  43.  
  44. """
  45. from __future__ import generators
  46.  
  47. try:
  48.     from itertools import ifilter, ifilterfalse
  49. except ImportError:
  50.     
  51.     def ifilter(predicate, iterable):
  52.         if predicate is None:
  53.             
  54.             def predicate(x):
  55.                 return x
  56.  
  57.         
  58.         for x in iterable:
  59.             if predicate(x):
  60.                 yield x
  61.                 continue
  62.         
  63.  
  64.     
  65.     def ifilterfalse(predicate, iterable):
  66.         if predicate is None:
  67.             
  68.             def predicate(x):
  69.                 return x
  70.  
  71.         
  72.         for x in iterable:
  73.             if not predicate(x):
  74.                 yield x
  75.                 continue
  76.         
  77.  
  78.     
  79.     try:
  80.         (True, False)
  81.     except NameError:
  82.         (True, False) = (0 == 0, 0 != 0)
  83.  
  84.  
  85. __all__ = [
  86.     'BaseSet',
  87.     'Set',
  88.     'ImmutableSet']
  89.  
  90. class BaseSet(object):
  91.     '''Common base class for mutable and immutable sets.'''
  92.     __slots__ = [
  93.         '_data']
  94.     
  95.     def __init__(self):
  96.         '''This is an abstract class.'''
  97.         if self.__class__ is BaseSet:
  98.             raise TypeError, 'BaseSet is an abstract class.  Use Set or ImmutableSet.'
  99.         
  100.  
  101.     
  102.     def __len__(self):
  103.         '''Return the number of elements of a set.'''
  104.         return len(self._data)
  105.  
  106.     
  107.     def __repr__(self):
  108.         """Return string representation of a set.
  109.  
  110.         This looks like 'Set([<list of elements>])'.
  111.         """
  112.         return self._repr()
  113.  
  114.     __str__ = __repr__
  115.     
  116.     def _repr(self, sorted = False):
  117.         elements = self._data.keys()
  118.         if sorted:
  119.             elements.sort()
  120.         
  121.         return '%s(%r)' % (self.__class__.__name__, elements)
  122.  
  123.     
  124.     def __iter__(self):
  125.         '''Return an iterator over the elements or a set.
  126.  
  127.         This is the keys iterator for the underlying dict.
  128.         '''
  129.         return self._data.iterkeys()
  130.  
  131.     
  132.     def __cmp__(self, other):
  133.         raise TypeError, "can't compare sets using cmp()"
  134.  
  135.     
  136.     def __eq__(self, other):
  137.         if isinstance(other, BaseSet):
  138.             return self._data == other._data
  139.         else:
  140.             return False
  141.  
  142.     
  143.     def __ne__(self, other):
  144.         if isinstance(other, BaseSet):
  145.             return self._data != other._data
  146.         else:
  147.             return True
  148.  
  149.     
  150.     def copy(self):
  151.         '''Return a shallow copy of a set.'''
  152.         result = self.__class__()
  153.         result._data.update(self._data)
  154.         return result
  155.  
  156.     __copy__ = copy
  157.     
  158.     def __deepcopy__(self, memo):
  159.         '''Return a deep copy of a set; used by copy module.'''
  160.         deepcopy = deepcopy
  161.         import copy
  162.         result = self.__class__()
  163.         memo[id(self)] = result
  164.         data = result._data
  165.         value = True
  166.         for elt in self:
  167.             data[deepcopy(elt, memo)] = value
  168.         
  169.         return result
  170.  
  171.     
  172.     def __or__(self, other):
  173.         '''Return the union of two sets as a new set.
  174.  
  175.         (I.e. all elements that are in either set.)
  176.         '''
  177.         if not isinstance(other, BaseSet):
  178.             return NotImplemented
  179.         
  180.         return self.union(other)
  181.  
  182.     
  183.     def union(self, other):
  184.         '''Return the union of two sets as a new set.
  185.  
  186.         (I.e. all elements that are in either set.)
  187.         '''
  188.         result = self.__class__(self)
  189.         result._update(other)
  190.         return result
  191.  
  192.     
  193.     def __and__(self, other):
  194.         '''Return the intersection of two sets as a new set.
  195.  
  196.         (I.e. all elements that are in both sets.)
  197.         '''
  198.         if not isinstance(other, BaseSet):
  199.             return NotImplemented
  200.         
  201.         return self.intersection(other)
  202.  
  203.     
  204.     def intersection(self, other):
  205.         '''Return the intersection of two sets as a new set.
  206.  
  207.         (I.e. all elements that are in both sets.)
  208.         '''
  209.         if not isinstance(other, BaseSet):
  210.             other = Set(other)
  211.         
  212.         if len(self) <= len(other):
  213.             little = self
  214.             big = other
  215.         else:
  216.             little = other
  217.             big = self
  218.         common = ifilter(big._data.has_key, little)
  219.         return self.__class__(common)
  220.  
  221.     
  222.     def __xor__(self, other):
  223.         '''Return the symmetric difference of two sets as a new set.
  224.  
  225.         (I.e. all elements that are in exactly one of the sets.)
  226.         '''
  227.         if not isinstance(other, BaseSet):
  228.             return NotImplemented
  229.         
  230.         return self.symmetric_difference(other)
  231.  
  232.     
  233.     def symmetric_difference(self, other):
  234.         '''Return the symmetric difference of two sets as a new set.
  235.  
  236.         (I.e. all elements that are in exactly one of the sets.)
  237.         '''
  238.         result = self.__class__()
  239.         data = result._data
  240.         value = True
  241.         selfdata = self._data
  242.         
  243.         try:
  244.             otherdata = other._data
  245.         except AttributeError:
  246.             otherdata = Set(other)._data
  247.  
  248.         for elt in ifilterfalse(otherdata.has_key, selfdata):
  249.             data[elt] = value
  250.         
  251.         for elt in ifilterfalse(selfdata.has_key, otherdata):
  252.             data[elt] = value
  253.         
  254.         return result
  255.  
  256.     
  257.     def __sub__(self, other):
  258.         '''Return the difference of two sets as a new Set.
  259.  
  260.         (I.e. all elements that are in this set and not in the other.)
  261.         '''
  262.         if not isinstance(other, BaseSet):
  263.             return NotImplemented
  264.         
  265.         return self.difference(other)
  266.  
  267.     
  268.     def difference(self, other):
  269.         '''Return the difference of two sets as a new Set.
  270.  
  271.         (I.e. all elements that are in this set and not in the other.)
  272.         '''
  273.         result = self.__class__()
  274.         data = result._data
  275.         
  276.         try:
  277.             otherdata = other._data
  278.         except AttributeError:
  279.             otherdata = Set(other)._data
  280.  
  281.         value = True
  282.         for elt in ifilterfalse(otherdata.has_key, self):
  283.             data[elt] = value
  284.         
  285.         return result
  286.  
  287.     
  288.     def __contains__(self, element):
  289.         """Report whether an element is a member of a set.
  290.  
  291.         (Called in response to the expression `element in self'.)
  292.         """
  293.         
  294.         try:
  295.             return element in self._data
  296.         except TypeError:
  297.             transform = getattr(element, '__as_temporarily_immutable__', None)
  298.             if transform is None:
  299.                 raise 
  300.             
  301.             return transform() in self._data
  302.  
  303.  
  304.     
  305.     def issubset(self, other):
  306.         '''Report whether another set contains this set.'''
  307.         self._binary_sanity_check(other)
  308.         if len(self) > len(other):
  309.             return False
  310.         
  311.         for elt in ifilterfalse(other._data.has_key, self):
  312.             return False
  313.         
  314.         return True
  315.  
  316.     
  317.     def issuperset(self, other):
  318.         '''Report whether this set contains another set.'''
  319.         self._binary_sanity_check(other)
  320.         if len(self) < len(other):
  321.             return False
  322.         
  323.         for elt in ifilterfalse(self._data.has_key, other):
  324.             return False
  325.         
  326.         return True
  327.  
  328.     __le__ = issubset
  329.     __ge__ = issuperset
  330.     
  331.     def __lt__(self, other):
  332.         self._binary_sanity_check(other)
  333.         if len(self) < len(other):
  334.             pass
  335.         return self.issubset(other)
  336.  
  337.     
  338.     def __gt__(self, other):
  339.         self._binary_sanity_check(other)
  340.         if len(self) > len(other):
  341.             pass
  342.         return self.issuperset(other)
  343.  
  344.     
  345.     def _binary_sanity_check(self, other):
  346.         if not isinstance(other, BaseSet):
  347.             raise TypeError, 'Binary operation only permitted between sets'
  348.         
  349.  
  350.     
  351.     def _compute_hash(self):
  352.         result = 0
  353.         for elt in self:
  354.             result ^= hash(elt)
  355.         
  356.         return result
  357.  
  358.     
  359.     def _update(self, iterable):
  360.         data = self._data
  361.         if isinstance(iterable, BaseSet):
  362.             data.update(iterable._data)
  363.             return None
  364.         
  365.         value = True
  366.  
  367.  
  368.  
  369. class ImmutableSet(BaseSet):
  370.     '''Immutable set class.'''
  371.     __slots__ = [
  372.         '_hashcode']
  373.     
  374.     def __init__(self, iterable = None):
  375.         '''Construct an immutable set from an optional iterable.'''
  376.         self._hashcode = None
  377.         self._data = { }
  378.         if iterable is not None:
  379.             self._update(iterable)
  380.         
  381.  
  382.     
  383.     def __hash__(self):
  384.         if self._hashcode is None:
  385.             self._hashcode = self._compute_hash()
  386.         
  387.         return self._hashcode
  388.  
  389.     
  390.     def __getstate__(self):
  391.         return (self._data, self._hashcode)
  392.  
  393.     
  394.     def __setstate__(self, state):
  395.         (self._data, self._hashcode) = state
  396.  
  397.  
  398.  
  399. class Set(BaseSet):
  400.     ''' Mutable set class.'''
  401.     __slots__ = []
  402.     
  403.     def __init__(self, iterable = None):
  404.         '''Construct a set from an optional iterable.'''
  405.         self._data = { }
  406.         if iterable is not None:
  407.             self._update(iterable)
  408.         
  409.  
  410.     
  411.     def __getstate__(self):
  412.         return (self._data,)
  413.  
  414.     
  415.     def __setstate__(self, data):
  416.         (self._data,) = data
  417.  
  418.     
  419.     def __hash__(self):
  420.         '''A Set cannot be hashed.'''
  421.         raise TypeError, "Can't hash a Set, only an ImmutableSet."
  422.  
  423.     
  424.     def __ior__(self, other):
  425.         '''Update a set with the union of itself and another.'''
  426.         self._binary_sanity_check(other)
  427.         self._data.update(other._data)
  428.         return self
  429.  
  430.     
  431.     def union_update(self, other):
  432.         '''Update a set with the union of itself and another.'''
  433.         self._update(other)
  434.  
  435.     
  436.     def __iand__(self, other):
  437.         '''Update a set with the intersection of itself and another.'''
  438.         self._binary_sanity_check(other)
  439.         self._data = (self & other)._data
  440.         return self
  441.  
  442.     
  443.     def intersection_update(self, other):
  444.         '''Update a set with the intersection of itself and another.'''
  445.         if isinstance(other, BaseSet):
  446.             self &= other
  447.         else:
  448.             self._data = self.intersection(other)._data
  449.  
  450.     
  451.     def __ixor__(self, other):
  452.         '''Update a set with the symmetric difference of itself and another.'''
  453.         self._binary_sanity_check(other)
  454.         self.symmetric_difference_update(other)
  455.         return self
  456.  
  457.     
  458.     def symmetric_difference_update(self, other):
  459.         '''Update a set with the symmetric difference of itself and another.'''
  460.         data = self._data
  461.         value = True
  462.         if not isinstance(other, BaseSet):
  463.             other = Set(other)
  464.         
  465.         if self is other:
  466.             self.clear()
  467.         
  468.         for elt in other:
  469.             if elt in data:
  470.                 del data[elt]
  471.                 continue
  472.             data[elt] = value
  473.         
  474.  
  475.     
  476.     def __isub__(self, other):
  477.         '''Remove all elements of another set from this set.'''
  478.         self._binary_sanity_check(other)
  479.         self.difference_update(other)
  480.         return self
  481.  
  482.     
  483.     def difference_update(self, other):
  484.         '''Remove all elements of another set from this set.'''
  485.         data = self._data
  486.         if not isinstance(other, BaseSet):
  487.             other = Set(other)
  488.         
  489.         if self is other:
  490.             self.clear()
  491.         
  492.         for elt in ifilter(data.has_key, other):
  493.             del data[elt]
  494.         
  495.  
  496.     
  497.     def update(self, iterable):
  498.         '''Add all values from an iterable (such as a list or file).'''
  499.         self._update(iterable)
  500.  
  501.     
  502.     def clear(self):
  503.         '''Remove all elements from this set.'''
  504.         self._data.clear()
  505.  
  506.     
  507.     def add(self, element):
  508.         '''Add an element to a set.
  509.  
  510.         This has no effect if the element is already present.
  511.         '''
  512.         
  513.         try:
  514.             self._data[element] = True
  515.         except TypeError:
  516.             transform = getattr(element, '__as_immutable__', None)
  517.             if transform is None:
  518.                 raise 
  519.             
  520.             self._data[transform()] = True
  521.  
  522.  
  523.     
  524.     def remove(self, element):
  525.         '''Remove an element from a set; it must be a member.
  526.  
  527.         If the element is not a member, raise a KeyError.
  528.         '''
  529.         
  530.         try:
  531.             del self._data[element]
  532.         except TypeError:
  533.             transform = getattr(element, '__as_temporarily_immutable__', None)
  534.             if transform is None:
  535.                 raise 
  536.             
  537.             del self._data[transform()]
  538.  
  539.  
  540.     
  541.     def discard(self, element):
  542.         '''Remove an element from a set if it is a member.
  543.  
  544.         If the element is not a member, do nothing.
  545.         '''
  546.         
  547.         try:
  548.             self.remove(element)
  549.         except KeyError:
  550.             pass
  551.  
  552.  
  553.     
  554.     def pop(self):
  555.         '''Remove and return an arbitrary set element.'''
  556.         return self._data.popitem()[0]
  557.  
  558.     
  559.     def __as_immutable__(self):
  560.         return ImmutableSet(self)
  561.  
  562.     
  563.     def __as_temporarily_immutable__(self):
  564.         return _TemporarilyImmutableSet(self)
  565.  
  566.  
  567.  
  568. class _TemporarilyImmutableSet(BaseSet):
  569.     
  570.     def __init__(self, set):
  571.         self._set = set
  572.         self._data = set._data
  573.  
  574.     
  575.     def __hash__(self):
  576.         return self._set._compute_hash()
  577.  
  578.  
  579.